package org.ccams.util;

import java.math.BigDecimal;
import java.util.*;

/**
 * 一些字符串处理的功能
 * @author liuguangshuai@gmail.com
 * @系统名称：定制化辅助生成制造系统
 * @时间：Aug 10, 2008
 */
public class StrHelper
{
  /**
   * 判断str字符串是否是in的子串
   * @param in String 主字符串
   * @param str String 需要测试的字符串
   * @return boolean true是in的子串;false不是in的子串
   */
  public static boolean containsString(String in, String str)
  {
    return ( ( (str == null) || (in == null) || (in.length() == 0) ||
              (str.length() == 0)) ? false :
            (in.indexOf(str) >= 0));
  }

  /**
   * 将两个字符串通过一个连接符连接起来
   * @param str1 String 字符串1
   * @param str2 String 字符串2
   * @param concatenator char 连接字符
   * @return String 连接起来的新字符串
   */
  public static String concat(String str1, String str2, char concatenator)
  {
    if (isEmpty(str1))
    {
      return str2;
    }
    else if (isEmpty(str2))
    {
      return str1;
    }
    else
    {
      return (str1 + concatenator + str2);
    }
  }

  /**
   * 去掉字符串中所有的空格，包括字符串前后以及字符串中间的空格,如果是null,返回的是""
   * @param str String 需要去掉空格的字符串
   * @return String 去掉空格后的新的字符串
   */
  public static String trim(String str)
  {
    return trim(str, true, false);
  }

  /**
   * 去掉字符串中的空格或者非数字和字母的字符,如果是null,返回的是""
   * @param str String 需要处理的字符串
   * @param trimSpaces boolean true去掉空格,false不去掉空格
   * @param trimNonAlpha boolean true去掉字母和数字以外的字符，false不去掉
   * @return String 去掉了所有空格或者非字母数字的新的字符串
   */
  public static String trim(String str, boolean trimSpaces,
                            boolean trimNonAlpha)
  {
    if ( (str == null) || str.equals(""))
    {
      return "";
    }

    int length = str.length();
    StringBuffer sb = new StringBuffer(length);
    for (int i = 0; i < length; i++)
    {
      char c = str.charAt(i);
      if ( (trimSpaces && Character.isSpaceChar(c)) ||
          (trimNonAlpha && !Character.isLetterOrDigit(c)))
      {
        continue;
      }
      sb.append(c);
    }
    String key = sb.toString();

    return key.trim();
  }

  /**
   * 将字符串转换成boolean值，如果字符串不是"true/false",则返回默认的boolean值
   * @param value String 字符串
   * @param defaultValue boolean 默认的布尔值
   * @return boolean 转换后的布尔值
   */
  public static boolean getBoolean(String value, boolean defaultValue)
  {
    try
    {
      return Boolean.valueOf(value).booleanValue();
    }
    catch (Exception e)
    {
      return defaultValue;
    }
  }

  /**
   * 将字符串值转换成int,如果出错，返回默认值
   * @param value String 字符串
   * @param defaultValue int 默认值
   * @return int 转化后的数值
   */
  public static int getInt(String value, int defaultValue)
  {
    try
    {
      return Integer.valueOf(value).intValue();
    }
    catch (Exception e)
    {
      return defaultValue;
    }
  }

  /**
   * 将字符串转化成float数值，如果出错，返回默认值
   * @param value String 字符串
   * @param defaultValue float 默认的float数值
   * @return float 转化后的float数值
   */
  public static float getFloat(String value, float defaultValue)
  {
    try
    {
      return Float.valueOf(value).floatValue();
    }
    catch (Exception e)
    {
      return defaultValue;
    }
  }

  /**
   * 将字符串的值转化成double数值，如果出错，返回默认的值
   * @param value String 字符串
   * @param defaultValue double 默认的double数值
   * @return double 转化成的double值
   */
  public static double getDouble(String value, double defaultValue)
  {
    try
    {
      return Double.valueOf(value).doubleValue();
    }
    catch (Exception e)
    {
      return defaultValue;
    }
  }
  
  /**
	 * 将字符串的值转化成BigDecimal数值，如果出错，返回默认的值
	 * @param value String 字符串
	 * @param defaultValue BigDecimal 默认的BigDecimal数值
	 * @return
	 */
	public static BigDecimal getBigDecimal(String value, int defaultValue) {
		try {
			return new BigDecimal(value);
		} catch (Exception e) {
			return new BigDecimal(defaultValue);
		}
	}

  /**
   * 将一个字符串转化成字符串数组
   * @param source String 字符串
   * @param delimiter String 字符串中的分隔符
   * @return String[] 返回的字符串数组
   */
  public static String[] toArray(String source, String delimiter)
  {
    List results = new ArrayList();
    if (source != null)
    {
      StringTokenizer tokenizer = new StringTokenizer(source, delimiter);
      while (tokenizer.hasMoreTokens())
      {
        String token = tokenizer.nextToken();
        results.add(token.trim());
      }
    }
    return (String[]) results.toArray(new String[0]);
  }

  /**
   * 判断字符串是否不为null或空格串
   * @param str 被判断的字符
   * @return true表示“不为”
   */
  public static boolean isNotEmptyStr(String str)
  {
    return! (str == null || (str.length() == 0));
  }

  /**
   * 判断字符串是否为null或空格串
   * @param str 被判断的字符
   * @return true表示“为”
   */
  public static boolean isEmptyStr(String str)
  {
    return (str == null || (str.length() == 0));
  }

  /**
   * 判断某一个字符串是否为空或者长度为0
   * @param value String 字符串
   * @return boolean true字符串为空，false字符串不为空
   */
  public static boolean isEmpty(String value)
  {
    return (value != null) ? (value.length() == 0) : true;
  }

  /**
   * 将一个字符串中某些字符替换成其它值
   * @param original String 原始字符串
   * @param find String 需要替换的字符串
   * @param substitute String 替换值
   * @return String 替换后的新的字符串
   */
  public static String replace(String original, String find, String substitute)
  {
    String result = original;
    int location = original.indexOf(find);

    while (location >= 0)
    {
      result = result.substring(0, location) + substitute +
          result.substring(location + find.length());
      location = result.indexOf(find, location + find.length());
    }
    return result;
  }


  /**
   * 把非标准时间格式的字符串转化为标准格式的
   * @param time String 待转化的字符串
   * @return String 转化后的字符串
   */
  public static String valueOfFullformat(String time)
  {
    time = time.trim();
    int pos = time.indexOf(":");

    if (pos < 0)
    {
      time += " 00:00:00.000";
    }
    else
    {
      if (time.indexOf(":", pos + 1) < 0)
      {
        time += ":00.000";
      }
    }
    return time;
  }

  /**
   * 把带时间的时间字符串转化为仅为年月日的,格式必须是 XXXX hh:mm
   * @param time String 带事件的字符串
   * @return String 不带时间的字符串
   */
  public static String valueOfDateFormat(String time)
  {
    if (isEmptyStr(time))
    {
      return "";
    }

    int pos = time.indexOf(":");
    if (pos > 0)
    {
      time = time.substring(0, pos - 3);
    }
    return time;
  }

  /**
   * 将yyyy-MM-dd格式的字符串转化成yyyyMMdd
   * @param date String yyyy-MM-dd格式的字符串
   * @return String yyyyMMdd格式的字符串
   */
  public static String getDateStr(String date)
  {
    int pos = date.indexOf("-");
    int pos2 = date.lastIndexOf("-");
    int month = Integer.parseInt(date.substring(pos + 1, pos2)); //获取月数（Java中默认为0-11）
    int day = Integer.parseInt(date.substring(pos2 + 1));

    return date.substring(0,pos) + String.valueOf(month + 100).substring(1) +
        String.valueOf(day + 100).substring(1);
  }
  /**
   * 将一个以逗号隔开的字符串转化成字符串数组
   * @param str String 以逗号隔开的字符串
   * @return String[] 字符串数组
   */
  public static String[] split(String str)
  {
    return split(str, ",");
  }


  /**
   * 将用指定符号格开的字符串转化成字符串数组
   * @param str 带有指定符号的字符串
   * @param delim 指定符号
   * @return 对应的字符串数组
   */
  public static String[] split(String str, String delim)
  {
    LinkedList list = new LinkedList();
    StringTokenizer st = new StringTokenizer(str,delim);

    while (st.hasMoreTokens())
        list.add(st.nextToken());

    int len = list.size();
    String[] data = new String[len];

    for(int i=0; i<len; i++)
      data[i] = (String)list.get(i);

    return data;
  }

  /**
   * 将一个字符串数组转换成用分隔符隔开的字符串
   * @param str String[]　字符串数组
   * @param delim String　分隔符
   * @return String 用分隔符隔开的字符串
   */
  public static String union(String[] str, String delim)
  {
    String unionStr = "";

    if(str != null)
    {
      for (int i = 0; i < str.length; i++)
      {
        unionStr += str[i] + delim;
      }

      //去掉最后一个分隔符
      if (!unionStr.equals(""))
        unionStr = unionStr.substring(0, unionStr.length() - delim.length());
    }

    return unionStr;
  }

  /**
   * 将一个字符串数组转换成用逗号符隔开的字符串
   * @param str String[] 字符串数组
   * @return String 用逗号符隔开的字符串
   */
  public static String union(String[] str)
  {
    return union(str,",");
  }
  
  /**
   * 转换字符串，如果值为null,返回""
   * @param str 字符串
   * @return 返回经过规整的字符串
   */
  public static String convertNullToEmpty(String str)
  {
    String convertedStr = str;
    if(convertedStr == null)
      convertedStr = "";

    return convertedStr;
  }

  /**
   * 将字符串中有空格的地方转化成<&nbsp>
   * @param str 普通字符串
   * @return 空格经过转化后的字符串
   */
  public static String convertNullToHTMLEmpty(String str)
  {
    String convertedStr = str;
    if(convertedStr == null)
      convertedStr = "&nbsp";

    return convertedStr;
  }
}
